home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / shells / zsh-3.000 / zsh-3 / home / ftp / pub / local / info / zsh.info-5 (.txt) < prev    next >
GNU Info File  |  1996-07-16  |  48KB  |  850 lines
  1. This is Info file zsh.info, produced by Makeinfo-1.63 from the input
  2. file ./zsh.texi.
  3. This is a texinfo version of the man page for the Z Shell, originally by
  4. Paul Falstad.  It was converted from the `zsh.1' file distributed with
  5. zsh v2.5.0 by Jonathan Hardwick, `jch@cs.cmu.edu' and updated/modified
  6. by Clive Messer, `clive@epos.demon.co.uk' to it's present state.
  7. File: zsh.info,  Node: Flags with arguments,  Next: Control Flags,  Prev: Simple Flags,  Up: Options Flags
  8. Flags with arguments
  9. --------------------
  10. These have user supplied arguments to determine how the list of
  11. completions is to be made up:
  12. `-k ARRAY'
  13.      Names taken from the elements of `$ARRAY' (note that the `$' does
  14.      not appear on the command  line).   Alternatively, the argument
  15.      `ARRAY' itself may be a set of space or comma separated values in
  16.      parentheses, in which any delimiter may be escaped with a
  17.      backslash; in this case the argument should be quoted.  For
  18.      example, `compctl -k "(cputime filesize datasize stacksize
  19.      coredumpsize resident descriptors)" limit'.
  20. `-g GLOBSTRING'
  21.      The GLOBSTRING is expanded using filename globbing; it should be
  22.      quoted to protect it from immediate expansion.  The resulting
  23.      filenames are taken as possible completions.  Use `*(/)' instead
  24.      of `*/' for directories.  The `fignore' special parameter is not
  25.      applied to the resulting files.  More than one pattern may be
  26.      given separated by blanks. (Note that brace expansion is not part
  27.      of globbing.  Use the syntax (`either|or') to match alternatives.)
  28. `-K FUNCTION'
  29.      Call the given function to get the completions.  The function is
  30.      passed two arguments: the prefix and the suffix of the word on
  31.      which completion is to be attempted, in other words those
  32.      characters before the cursor position, and those from the cursor
  33.      position onwards.  The function should set the variable `reply' to
  34.      an array containing the completions (one completion per element);
  35.      note that `reply' should not be made local to the function.  From
  36.      such a function the command line can be accessed with the `-c' and
  37.      `-l' flags to the `read' builtin.  For example,
  38.      `function whoson { reply=(`users`); }'
  39.      `compctl -K whoson talk'
  40.      completes only logged-on users after `talk'.  Note that `whoson'
  41.      must return an array so that just `reply=`users`' is incorrect.
  42. `-H NUM PATTERN'
  43.      The possible completions are taken from the last NUM history
  44.      lines.  Only words matching PATTERN are taken.  If NUM is zero or
  45.      negative the whole history is searched and if PATTERN is the empty
  46.      string all words are taken (as with `*').  A typical use is
  47.      `compctl -D -f + -H 0 '' -X '(No file found; using history)''
  48.      which forces completion to look back in the history list for a
  49.      word if no filename matches.  The explanation string is useful as
  50.      it tells the user that no file of that name exists, which is
  51.      otherwise ambiguous.  (See the next section for `-X'.)
  52. File: zsh.info,  Node: Control Flags,  Prev: Flags with arguments,  Up: Options Flags
  53. Control Flags
  54. -------------
  55. These do not directly specify types of name to be completed, but
  56. manipulate the options that do:
  57.      It instructs the shell not to quote any meta-characters in the
  58.      possible completions.  This allows, for example, a completion
  59.      array (`-k') to complete to a back-quoted expression without
  60.      actually executing the back-quoted command until the entire
  61.      command is finally executed.  Normally meta-characters are
  62.      automatically quoted, so that user-defined completions don't need
  63.      to do the required quoting, which would be difficult to get right
  64.      anyway, especially when completing inside quotes.
  65. `-P PREFIX'
  66.      The PREFIX is inserted just before the completed string; any
  67.      initial part already typed will be completed and the whole PREFIX
  68.      ignored for completion purposes.  For example,
  69.      `compctl -j -P "%" kill'
  70.      inserts a `%' after the `kill' command and then completes job
  71.      names.
  72. `-S SUFFIX'
  73.      When a completion is found the SUFFIX is inserted after the
  74.      completed string.  In the case of menu completion the SUFFIX is
  75.      inserted immediately, but it is still possible to cycle through
  76.      the list of completions by repeatedly hitting the same key.
  77.      If used with the previous option (the `-S' flag) it causes the
  78.      suffix to be removed if the next character typed is a blank or does
  79.      not insert anything;  this is the same rule as used for the
  80.      `AUTO_REMOVE_SLASH' option.  This is most useful for list
  81.      separators (comma, colon, etc.).
  82. `-l CMD'
  83.      This option cannot be combined with any other option.  It
  84.      restricts the range of command line words that are considered to be
  85.      arguments.  If combined with one of the extended completion
  86.      patterns `p[...]', `r[...]', or `R[...]' (*Note Extended
  87.      Completion::.) the range is restricted to the arguments specified
  88.      in the brackets.  Completion is then performed as if these had
  89.      been given as arguments to the CMD supplied with the option.  If
  90.      the CMD string is empty the first word in the range is instead
  91.      taken as the command name, and command name completion performed
  92.      on the first word in the range.  For example,
  93.      `compctl -x 'r[-exec,;]' -l '' -- find'
  94.      completes arguments between `-exec' and the following `;' (or the
  95.      end of the command line if there is no such string) as if they
  96.      were a separate command line.
  97.      Use the whole list of possible completions, whether or not they
  98.      actually match the word on the command line.  The word typed so
  99.      far will be deleted.  This is most useful with a function (the
  100.      `-K' option), which can examine the word components passed to it
  101.      (or via the `read' builtins `-c' and `-l' flags) and use its own
  102.      criteria to decide what matches.  If there is no completion, the
  103.      original word is retained.
  104. `-X EXPLANATION'
  105.      Print EXPLANATION when trying completion on the current set of
  106.      options.  A `%n' in this string is replaced by the number of
  107.      matches.
  108. File: zsh.info,  Node: Alternative Completion,  Next: Extended Completion,  Prev: Options Flags,  Up: Programmable Completion
  109. Alternative Completion
  110. ======================
  111. `compctl [ -CDT ] OPTIONS + OPTIONS [ + ... ] [ + ] COMMAND ...'
  112. The form with `+' specifies alternative OPTIONS.  Completion is tried
  113. with the OPTIONS before the first `+'.  If this produces no matches
  114. completion is tried with the flags after the `+' and so on.  If there
  115. are no flags after the last `+' and a match has not been found up to
  116. that point, default completion is tried.
  117. File: zsh.info,  Node: Extended Completion,  Next: Example,  Prev: Alternative Completion,  Up: Programmable Completion
  118. Extended Completion
  119. ===================
  120. `compctl  [  -CDT  ]  OPTIONS -x PATTERN OPTIONS - ... -- [ COMMAND ...
  121. `compctl [ -CDT ] OPTIONS [ -x PATTERN OPTIONS - ... -- ]'
  122. `        [ + OPTIONS [ -x ... -- ] ... [+] ] [ COMMAND ... ]'
  123. The form with `-x' specifies extended completion for the commands
  124. given; as shown, it may be combined with alternative completion using
  125. `+'.  Each PATTERN is examined in turn; when a match is found, the
  126. corresponding OPTIONS, as described in *Note Options Flags::, are used
  127. to generate possible completions.  If no PATTERN matches, the OPTIONS
  128. given before the `-x' are used.
  129. Note that each pattern should be supplied as a single argument and
  130. should be quoted to prevent expansion of meta-characters by the shell.
  131. A PATTERN is built of sub-patterns separated by commas; it matches if
  132. at least one of these sub-patterns matches (they are `or''ed).  These
  133. sub-patterns are in turn composed of other sub-patterns separated by
  134. white spaces which match if all of the sub-patterns match (they are
  135. `and''ed).  An element of the sub-patterns is of the  form
  136. `c[...][...]', where the pairs of brackets may be repeated as often as
  137. necessary, and matches if any of the sets of brackets match (an `or').
  138. The example below makes this clearer.
  139. The elements may be any of the following:
  140. `S[STRING] ...'
  141.      The pattern matches if the current word on the command line starts
  142.      with one of the strings given in brackets.  The STRING is not
  143.      removed and is not part of the completion.
  144. `S[STRING] ...'
  145.      Like S[STRING] except that the STRING is part of the completion.
  146. `P[FROM,TO] ...'
  147.      The pattern matches if the number of the current word is between
  148.      one of the FROM and TO pairs inclusive.  The comma and TO are
  149.      optional; TO defaults to the same value as FROM.  The numbers may
  150.      be negative: `-n' refers to the `n''th last word on the line.
  151. `C[OFFSET,STRING] ...'
  152.      The pattern matches if the STRING matches the word OFFSET by
  153.      OFFSET from the current word position.  Usually OFFSET will be
  154.      negative.
  155. `C[OFFSET,PATTERN] ...'
  156.      Like C but using pattern matching instead.
  157. `W[INDEX,STRING] ...'
  158.      The pattern matches if the word in position INDEX is equal to the
  159.      corresponding  STRING.  Note that the word count is made after any
  160.      alias expansion.
  161. `W[INDEX,PATTERN] ...'
  162.      Like W but using pattern matching instead.
  163. `N[INDEX,STRING] ...'
  164.      Matches if the current word contains STRING.  Anything up to and
  165.      including the INDEX'th occurrence of this STRING will not be
  166.      considered part of the completion, but the rest will.  INDEX may be
  167.      negative to count from the end: in most cases, INDEX will be 1 or
  168.      -1.
  169. `N[INDEX,STRING] ...'
  170.      Like N[INDEX,STRING] except that the STRING will be taken as a
  171.      character class.  Anything up to and including the INDEX'th
  172.      occurrence of any of the characters in STRING will not be
  173.      considered part of the completion.
  174. `M[MIN,MAX] ...'
  175.      Matches if the total number of words lies between MIN and MAX
  176.      inclusive.
  177. `R[STR1,STR2] ...'
  178.      Matches if the cursor is after a word with prefix STR1.  If there
  179.      is also a word with prefix STR2 on the command line it matches
  180.      only if the cursor is before this word.
  181. `R[STR1,STR2] ...'
  182.      Like R but using pattern matching instead.
  183. File: zsh.info,  Node: Example,  Prev: Extended Completion,  Up: Programmable Completion
  184. Example
  185. =======
  186. `compctl -u -x 's[+] c[-1,-f],s[-f+]' -g '~/Mail/*(:t)' -
  187. 's[-f],c[-1,-f]' -f -- mail'
  188. This is to be interpreted as follows:
  189. If the current command is `mail', then
  190. if  ((the current word begins with `+' and the previous word is `-f')
  191. or (the current word begins with `-f+')), then complete the
  192. non-directory part (the `:t' glob modifier) of files in the directory
  193. `~/Mail'; else
  194. if the current word begins with `-f' or the previous word was `-f',
  195. then complete any file; else
  196. complete user names.
  197. File: zsh.info,  Node: Concept Index,  Next: Variables Index,  Prev: Programmable Completion,  Up: Top
  198. Concept Index
  199. *************
  200. * Menu:
  201. * alias:                                Shell Builtin Commands.
  202. * aliases, completion of:               Options.
  203. * aliases, global:                      Aliasing.
  204. * aliases, removing:                    Shell Builtin Commands.
  205. * aliasing:                             Aliasing.
  206. * alternate forms for complex commands: Alternate Forms For Complex Commands.
  207. * ambiguous completions:                Options.
  208. * annoying keyboard, sun:               Options.
  209. * arithmetic evaluation:                Arithmetic Evaluation.
  210. * arithmetic expansion:                 Arithmetic Expansion.
  211. * arithmetic operators:                 Arithmetic Evaluation.
  212. * array elements:                       Array Parameters.
  213. * array expansion, rc style:            Parameter Expansion.
  214. * array parameter, declaring:           Shell Builtin Commands.
  215. * arrays, ksh style:                    Options.
  216. * author:                               Author.
  217. * autoloading functions:                Shell Builtin Commands.
  218. * background jobs, IO:                  Jobs & Signals.
  219. * background jobs, notification:        Options.
  220. * background jobs, priority of:         Options.
  221. * beep, ambiguous completion:           Options.
  222. * beep, disabling:                      Options.
  223. * beep, history:                        Options.
  224. * bindings, key:                        Zsh Line Editor.
  225. * brace expansion:                      Brace Expansion.
  226. * brace expansion, disabling:           Options.
  227. * brace expansion, extending:           Options.
  228. * builtin commands:                     Shell Builtin Commands.
  229. * case selection:                       Complex Commands.
  230. * cd, automatic:                        Options.
  231. * cd, behaving like pushd:              Options.
  232. * cd, to parameter:                     Options.
  233. * clobbering, of files:                 Options.
  234. * command execution:                    Command Execution.
  235. * command execution, preventing:        Options.
  236. * command hashing:                      Options.
  237. * command substitution:                 Command Substitution.
  238. * commands, alternate forms for complex: Alternate Forms For Complex Commands.
  239. * commands, complex:                    Complex Commands.
  240. * commands, disabling:                  Shell Builtin Commands.
  241. * commands, simple:                     Simple Commands & Pipelines.
  242. * comments:                             Comments.
  243. * comments, in interactive shells:      Options.
  244. * compatibility, csh:                   Shell Builtin Commands.
  245. * compatibility, ksh:                   Shell Builtin Commands.
  246. * compatibility, sh:                    Shell Builtin Commands.
  247. * completion, beep on ambiguous:        Options.
  248. * completion, controlling:              Programmable Completion.
  249. * completion, exact matches:            Options.
  250. * completion, listing choices:          Options.
  251. * completion, menu:                     Options.
  252. * completion, menu, on TAB:             Options.
  253. * completion, programmable:             Programmable Completion.
  254. * completions, ambiguous:               Options.
  255. * complex commands:                     Complex Commands.
  256. * conditional expressions:              Conditional Expressions.
  257. * continuing loops:                     Shell Builtin Commands.
  258. * coprocesses:                          Simple Commands & Pipelines.
  259. * correction, spelling:                 Options.
  260. * csh, compatibility:                   Shell Builtin Commands.
  261. * csh, history style:                   Options.
  262. * csh, loop style:                      Options.
  263. * csh, null command style:              Parameters Used By The Shell.
  264. * csh, null globbing style:             Options.
  265. * csh, quoting style:                   Options.
  266. * csh, tilde expansion:                 Parameter Expansion.
  267. * descriptors, file:                    Redirection.
  268. * directories, changing:                Shell Builtin Commands.
  269. * directories, hashing:                 Options.
  270. * directories, marking:                 Options.
  271. * directories, named <1>:               Options.
  272. * directories, named:                   Filename Expansion.
  273. * directory stack, ignoring dups:       Options.
  274. * directory stack, printing:            Shell Builtin Commands.
  275. * directory stack, silencing:           Options.
  276. * disabling brace expansion:            Options.
  277. * disabling commands:                   Shell Builtin Commands.
  278. * disabling globbing:                   Options.
  279. * disabling history substitution:       Options.
  280. * disabling the beep:                   Options.
  281. * disabling the editor:                 Options.
  282. * disowning jobs:                       Jobs & Signals.
  283. * echo, BSD compatible:                 Options.
  284. * editing parameters:                   Shell Builtin Commands.
  285. * editing the history:                  Shell Builtin Commands.
  286. * editor, disabling:                    Options.
  287. * editor, line:                         Zsh Line Editor.
  288. * editor, modes:                        Zsh Line Editor.
  289. * editor, overstrike mode:              Options.
  290. * editor, single line mode:             Options.
  291. * EOF, ignoring:                        Options.
  292. * evaluating arguments as commands:     Shell Builtin Commands.
  293. * evaluation, arithmetic:               Arithmetic Evaluation.
  294. * event designators, history:           Event Designators.
  295. * exclusion, globbing:                  Filename Generation.
  296. * execution, of commands:               Command Execution.
  297. * execution, timed:                     Shell Builtin Commands.
  298. * exit status, printing:                Options.
  299. * exit status, trapping:                Options.
  300. * exiting loops:                        Shell Builtin Commands.
  301. * expanding parameters:                 Shell Builtin Commands.
  302. * expansion:                            Expansion.
  303. * expansion, arithmetic:                Arithmetic Expansion.
  304. * expansion, brace:                     Brace Expansion.
  305. * expansion, brace, disabling:          Options.
  306. * expansion, brace, extended:           Options.
  307. * expansion, filename:                  Filename Expansion.
  308. * expansion, history:                   History Expansion.
  309. * expansion, parameter:                 Parameter Expansion.
  310. * export, automatic:                    Options.
  311. * expressions, conditional:             Conditional Expressions.
  312. * features, undocumented:               Undocumented Features.
  313. * file clobbering, preventing:          Options.
  314. * file descriptors:                     Redirection.
  315. * file, history:                        Shell Builtin Commands.
  316. * filename expansion:                   Filename Expansion.
  317. * filename generation:                  Filename Generation.
  318. * filename substitution, =:             Options.
  319. * files used:                           Invocation.
  320. * files, marking type of:               Options.
  321. * files, shutdown:                      Invocation.
  322. * files, startup:                       Invocation.
  323. * files, temporary:                     Process Substitution.
  324. * flags, shell:                         Invocation.
  325. * flow control:                         Options.
  326. * for loops:                            Complex Commands.
  327. * functions:                            Functions.
  328. * functions, autoloading:               Shell Builtin Commands.
  329. * functions, removing:                  Shell Builtin Commands.
  330. * functions, returning from:            Shell Builtin Commands.
  331. * globbing:                             Filename Generation.
  332. * globbing, disabling:                  Options.
  333. * globbing, excluding patterns:         Filename Generation.
  334. * globbing, extended:                   Options.
  335. * globbing, malformed pattern:          Options.
  336. * globbing, no matches:                 Options.
  337. * globbing, null, csh style:            Options.
  338. * globbing, of . files:                 Options.
  339. * globbing, qualifiers:                 Filename Generation.
  340. * globbing, sh style:                   Options.
  341. * grammar, shell:                       Shell Grammar.
  342. * hashing, of commands:                 Options.
  343. * hashing, of directories:              Options.
  344. * history:                              History Expansion.
  345. * history event designators:            Event Designators.
  346. * history expansion:                    History Expansion.
  347. * history modifiers:                    Modifiers.
  348. * history word designators:             Word Designators.
  349. * history, appending to file:           Options.
  350. * history, beeping:                     Options.
  351. * history, disabling substitution:      Options.
  352. * history, editing:                     Shell Builtin Commands.
  353. * history, file:                        Shell Builtin Commands.
  354. * history, ignoring duplicates:         Options.
  355. * history, ignoring spaces:             Options.
  356. * history, timestamping:                Options.
  357. * history, verifying substitution:      Options.
  358. * if construct:                         Complex Commands.
  359. * integer parameters:                   Arithmetic Evaluation.
  360. * invocation:                           Invocation.
  361. * job control, allowing:                Options.
  362. * jobs:                                 Jobs & Signals.
  363. * jobs, background priority:            Options.
  364. * jobs, background, IO:                 Jobs & Signals.
  365. * jobs, disowning:                      Jobs & Signals.
  366. * jobs, killing:                        Shell Builtin Commands.
  367. * jobs, list format:                    Options.
  368. * jobs, nohup:                          Options.
  369. * jobs, referring to:                   Jobs & Signals.
  370. * jobs, resuming automatically:         Options.
  371. * jobs, suspending:                     Jobs & Signals.
  372. * jobs, waiting for:                    Shell Builtin Commands.
  373. * key bindings:                         Zsh Line Editor.
  374. * keys, rebinding:                      Shell Builtin Commands.
  375. * killing jobs:                         Shell Builtin Commands.
  376. * ksh, compatibility:                   Shell Builtin Commands.
  377. * ksh, editor mode:                     Zsh Line Editor.
  378. * ksh, null command style:              Parameters Used By The Shell.
  379. * ksh, option printing style:           Options.
  380. * ksh, style arrays:                    Options.
  381. * limits, resource:                     Shell Builtin Commands.
  382. * line editor:                          Zsh Line Editor.
  383. * line, reading:                        Shell Builtin Commands.
  384. * links, symbolic:                      Options.
  385. * list:                                 Simple Commands & Pipelines.
  386. * list format, of jobs:                 Options.
  387. * loop style, csh:                      Options.
  388. * loops, continuing:                    Shell Builtin Commands.
  389. * loops, exiting:                       Shell Builtin Commands.
  390. * loops, for:                           Complex Commands.
  391. * loops, repeat:                        Complex Commands.
  392. * loops, until:                         Complex Commands.
  393. * loops, while:                         Complex Commands.
  394. * mail, warning of arrival:             Options.
  395. * mailing lists:                        Mailing Lists.
  396. * marking directories:                  Options.
  397. * marking file types:                   Options.
  398. * mode, privileged:                     Options.
  399. * modifiers, history:                   Modifiers.
  400. * modifiers, precommand:                Precommand Modifiers.
  401. * named directories:                    Filename Expansion.
  402. * notification of background jobs:      Options.
  403. * null command, setting:                Parameters Used By The Shell.
  404. * null globbing, csh style:             Options.
  405. * operators, arithmetic:                Arithmetic Evaluation.
  406. * option printing, ksh style:           Options.
  407. * options:                              Options.
  408. * options, processing:                  Shell Builtin Commands.
  409. * options, setting:                     Shell Builtin Commands.
  410. * options, unsetting:                   Shell Builtin Commands.
  411. * overstrike mode, of editor:           Options.
  412. * parameter expansion:                  Parameter Expansion.
  413. * parameters:                           Parameters.
  414. * parameters, array:                    Shell Builtin Commands.
  415. * parameters, editing:                  Shell Builtin Commands.
  416. * parameters, error on substituting unset: Options.
  417. * parameters, expanding:                Shell Builtin Commands.
  418. * parameters, integer:                  Arithmetic Evaluation.
  419. * parameters, marking readonly:         Shell Builtin Commands.
  420. * parameters, positional:               Shell Builtin Commands.
  421. * parameters, setting:                  Shell Builtin Commands.
  422. * parameters, unsetting:                Shell Builtin Commands.
  423. * path search, extended:                Options.
  424. * pipeline:                             Simple Commands & Pipelines.
  425. * popd, controlling syntax:             Options.
  426. * precommand modifiers:                 Precommand Modifiers.
  427. * privileged mode:                      Options.
  428. * process substitution:                 Process Substitution.
  429. * prompt, without CR:                   Options.
  430. * pushd, making cd behave like:         Options.
  431. * pushd, to home:                       Options.
  432. * qualifiers, globbing:                 Filename Generation.
  433. * querying before rm *:                 Options.
  434. * quoting:                              Quoting.
  435. * quoting style, csh:                   Options.
  436. * quoting style, rc:                    Options.
  437. * rc, array expansion style:            Parameter Expansion.
  438. * rc, quoting style:                    Options.
  439. * reading a line:                       Shell Builtin Commands.
  440. * rebinding the keys:                   Shell Builtin Commands.
  441. * redirection:                          Redirection.
  442. * referring to jobs:                    Jobs & Signals.
  443. * repeat loops:                         Complex Commands.
  444. * reserved words:                       Reserved Words.
  445. * resource limits:                      Shell Builtin Commands.
  446. * resuming jobs automatically:          Options.
  447. * rm *, querying before:                Options.
  448. * selection, case:                      Complex Commands.
  449. * selection, user:                      Complex Commands.
  450. * sh, compatibility:                    Shell Builtin Commands.
  451. * sh, globbing style:                   Options.
  452. * sh, word splitting style <1>:         Options.
  453. * sh, word splitting style:             Parameter Expansion.
  454. * shell flags:                          Invocation.
  455. * shell grammar:                        Shell Grammar.
  456. * shell, suspending:                    Shell Builtin Commands.
  457. * shell, timing:                        Shell Builtin Commands.
  458. * signals:                              Jobs & Signals.
  459. * signals, trapping <1>:                Shell Builtin Commands.
  460. * signals, trapping:                    Functions.
  461. * simple commands:                      Simple Commands & Pipelines.
  462. * single command:                       Options.
  463. * slash, removing trailing:             Options.
  464. * sorting, numerically:                 Options.
  465. * spelling correction:                  Options.
  466. * startup files:                        Invocation.
  467. * startup files, sourcing:              Options.
  468. * sublist:                              Simple Commands & Pipelines.
  469. * subshells:                            Complex Commands.
  470. * substitution, command:                Command Substitution.
  471. * substitution, process:                Process Substitution.
  472. * substrings:                           Array Parameters.
  473. * sun keyboard, annoying:               Options.
  474. * suspending jobs:                      Jobs & Signals.
  475. * symbolic links:                       Options.
  476. * temporary files:                      Process Substitution.
  477. * termcap string, printing:             Shell Builtin Commands.
  478. * testing conditional expression:       Complex Commands.
  479. * tilde expansion, csh:                 Parameter Expansion.
  480. * timed execution:                      Shell Builtin Commands.
  481. * timing:                               Complex Commands.
  482. * timing the shell:                     Shell Builtin Commands.
  483. * tracing, of commands:                 Options.
  484. * tracing, of input lines:              Options.
  485. * trapping signals <1>:                 Shell Builtin Commands.
  486. * trapping signals:                     Functions.
  487. * tty, freezing:                        Shell Builtin Commands.
  488. * umask:                                Shell Builtin Commands.
  489. * unset parameters, error on substituting: Options.
  490. * until loops:                          Complex Commands.
  491. * user selection:                       Complex Commands.
  492. * users, watching:                      Shell Builtin Commands.
  493. * waiting for jobs:                     Shell Builtin Commands.
  494. * watching users:                       Shell Builtin Commands.
  495. * while loops:                          Complex Commands.
  496. * word designators, history:            Word Designators.
  497. * word splitting, sh style <1>:         Options.
  498. * word splitting, sh style:             Parameter Expansion.
  499. File: zsh.info,  Node: Variables Index,  Next: Options Index,  Prev: Concept Index,  Up: Top
  500. Variables Index
  501. ***************
  502. * Menu:
  503. * !:                                    Parameters Set By The Shell.
  504. * #:                                    Parameters Set By The Shell.
  505. * $:                                    Parameters Set By The Shell.
  506. * *:                                    Parameters Set By The Shell.
  507. * -:                                    Parameters Set By The Shell.
  508. * ?:                                    Parameters Set By The Shell.
  509. * @:                                    Parameters Set By The Shell.
  510. * _:                                    Parameters Set By The Shell.
  511. * ARGC:                                 Parameters Set By The Shell.
  512. * argv:                                 Parameters Set By The Shell.
  513. * ARGV0:                                Parameters Used By The Shell.
  514. * BAUD:                                 Parameters Used By The Shell.
  515. * cdpath:                               Parameters Used By The Shell.
  516. * COLUMNS:                              Parameters Used By The Shell.
  517. * DIRSTACKSIZE:                         Parameters Used By The Shell.
  518. * EDITOR:                               Zsh Line Editor.
  519. * EGID:                                 Parameters Set By The Shell.
  520. * ERRNO:                                Parameters Set By The Shell.
  521. * EUID:                                 Parameters Set By The Shell.
  522. * FCEDIT:                               Parameters Used By The Shell.
  523. * fignore:                              Parameters Used By The Shell.
  524. * fpath:                                Parameters Used By The Shell.
  525. * GID:                                  Parameters Set By The Shell.
  526. * histchars:                            Parameters Used By The Shell.
  527. * histchars, use of:                    Comments.
  528. * HISTFILE:                             Parameters Used By The Shell.
  529. * HISTSIZE:                             Parameters Used By The Shell.
  530. * HISTSIZE, use of:                     History Expansion.
  531. * HOME:                                 Parameters Used By The Shell.
  532. * HOST:                                 Parameters Set By The Shell.
  533. * IFS <1>:                              Shell Builtin Commands.
  534. * IFS:                                  Parameters Used By The Shell.
  535. * IFS, use of <1>:                      Command Substitution.
  536. * IFS, use of:                          Parameter Expansion.
  537. * KEYTIMEOUT:                           Parameters Used By The Shell.
  538. * LINENO:                               Parameters Set By The Shell.
  539. * LINES:                                Parameters Used By The Shell.
  540. * LISTMAX:                              Parameters Used By The Shell.
  541. * LOGCHECK:                             Parameters Used By The Shell.
  542. * LOGNAME:                              Parameters Set By The Shell.
  543. * MACHTYPE:                             Parameters Set By The Shell.
  544. * MAIL:                                 Parameters Used By The Shell.
  545. * MAILCHECK:                            Parameters Used By The Shell.
  546. * mailpath:                             Parameters Used By The Shell.
  547. * manpath:                              Parameters Used By The Shell.
  548. * NULLCMD:                              Parameters Used By The Shell.
  549. * OLDPWD:                               Parameters Set By The Shell.
  550. * OPTARG:                               Parameters Set By The Shell.
  551. * OPTARG, use of:                       Shell Builtin Commands.
  552. * OPTIND:                               Parameters Set By The Shell.
  553. * OPTIND, use of:                       Shell Builtin Commands.
  554. * OSTYPE:                               Parameters Set By The Shell.
  555. * path:                                 Parameters Used By The Shell.
  556. * path, use of:                         Command Execution.
  557. * PERIOD:                               Functions.
  558. * POSTEDIT:                             Parameters Used By The Shell.
  559. * PPID:                                 Parameters Set By The Shell.
  560. * PROMPT:                               Parameters Used By The Shell.
  561. * PROMPT2:                              Parameters Used By The Shell.
  562. * PROMPT3:                              Parameters Used By The Shell.
  563. * PROMPT4:                              Parameters Used By The Shell.
  564. * PS1:                                  Parameters Used By The Shell.
  565. * PS2:                                  Parameters Used By The Shell.
  566. * PS3:                                  Parameters Used By The Shell.
  567. * PS4:                                  Parameters Used By The Shell.
  568. * psvar:                                Parameters Used By The Shell.
  569. * PWD:                                  Parameters Set By The Shell.
  570. * RANDOM:                               Parameters Set By The Shell.
  571. * READNULLCMD:                          Parameters Used By The Shell.
  572. * REPORTTIME:                           Parameters Used By The Shell.
  573. * RPROMPT:                              Parameters Used By The Shell.
  574. * RPS1:                                 Parameters Used By The Shell.
  575. * SAVEHIST:                             Parameters Used By The Shell.
  576. * SECONDS:                              Parameters Set By The Shell.
  577. * SHLVL:                                Parameters Set By The Shell.
  578. * signals:                              Parameters Set By The Shell.
  579. * SPROMPT:                              Parameters Used By The Shell.
  580. * status:                               Parameters Set By The Shell.
  581. * STTY:                                 Parameters Used By The Shell.
  582. * TERM:                                 Zsh Line Editor.
  583. * TIMEFMT:                              Parameters Used By The Shell.
  584. * TMOUT:                                Parameters Used By The Shell.
  585. * TMPPREFIX:                            Parameters Used By The Shell.
  586. * TTY:                                  Parameters Set By The Shell.
  587. * TTYIDLE:                              Parameters Set By The Shell.
  588. * UID:                                  Parameters Set By The Shell.
  589. * USERNAME:                             Parameters Set By The Shell.
  590. * VENDOR:                               Parameters Set By The Shell.
  591. * VISUAL:                               Zsh Line Editor.
  592. * watch:                                Parameters Used By The Shell.
  593. * watch, use of:                        Shell Builtin Commands.
  594. * WATCHFMT:                             Parameters Used By The Shell.
  595. * WORDCHARS:                            Parameters Used By The Shell.
  596. * ZDOTDIR:                              Parameters Used By The Shell.
  597. * ZSH_NAME:                             Parameters Set By The Shell.
  598. * ZSH_VERSION:                          Parameters Set By The Shell.
  599. * ZSHNAME:                              Parameters Set By The Shell.
  600. File: zsh.info,  Node: Options Index,  Next: Functions Index,  Prev: Variables Index,  Up: Top
  601. Options Index
  602. *************
  603. * Menu:
  604. * ALL_EXPORT:                           Options.
  605. * ALWAYS_LAST_PROMPT:                   Options.
  606. * ALWAYS_TO_END:                        Options.
  607. * APPEND_HISTORY:                       Options.
  608. * AUTO_CD:                              Options.
  609. * AUTO_LIST:                            Options.
  610. * AUTO_MENU:                            Options.
  611. * AUTO_NAME_DIRS:                       Options.
  612. * AUTO_PARAM_KEYS:                      Options.
  613. * AUTO_PARAM_SLASH:                     Options.
  614. * AUTO_PUSHD:                           Options.
  615. * AUTO_PUSHD, use of:                   Parameters Used By The Shell.
  616. * AUTO_REMOVE_SLASH:                    Options.
  617. * AUTO_RESUME:                          Options.
  618. * BGNICE:                               Options.
  619. * BRACE_CCL:                            Options.
  620. * BRACE_CCL, use of:                    Brace Expansion.
  621. * BSD_ECHO:                             Options.
  622. * BSD_ECHO, use of:                     Shell Builtin Commands.
  623. * CDABLE_VARS:                          Options.
  624. * CDABLEVARS, use of:                   Shell Builtin Commands.
  625. * CHASE_LINKS:                          Options.
  626. * CHASE_LINKS, use of:                  Shell Builtin Commands.
  627. * COMPLETE_ALIASES:                     Options.
  628. * COMPLETE_IN_WORD:                     Options.
  629. * CORRECT:                              Options.
  630. * CORRECT_ALL:                          Options.
  631. * CSH_JUNKIE_HISTORY:                   Options.
  632. * CSH_JUNKIE_LOOPS <1>:                 Options.
  633. * CSH_JUNKIE_LOOPS:                     Parameter Expansion.
  634. * CSH_JUNKIE_QUOTES:                    Options.
  635. * CSH_NULL_GLOB:                        Options.
  636. * ERR_EXIT:                             Options.
  637. * EXTENDED_GLOB:                        Options.
  638. * EXTENDED_GLOB, use of:                Filename Generation.
  639. * EXTENDED_HISTORY:                     Options.
  640. * GLOB_ASSIGN:                          Options.
  641. * GLOB_COMPLETE:                        Options.
  642. * GLOB_DOTS:                            Options.
  643. * GLOB_DOTS, setting in pattern:        Filename Generation.
  644. * GLOB_DOTS, use of:                    Filename Generation.
  645. * GLOB_SUBST:                           Options.
  646. * HASH_CMDS:                            Options.
  647. * HASH_DIRS:                            Options.
  648. * HASH_LIST_ALL:                        Options.
  649. * HIST_ALLOW_CLOBBER:                   Options.
  650. * HIST_IGNORE_DUPS:                     Options.
  651. * HIST_IGNORE_SPACE:                    Options.
  652. * HIST_NO_STORE:                        Options.
  653. * HIST_VERIFY:                          Options.
  654. * IGNORE_BRACES:                        Options.
  655. * IGNORE_EOF:                           Options.
  656. * IGNORE_EOF, use of:                   Shell Builtin Commands.
  657. * INTERACTIVE:                          Options.
  658. * INTERACTIVE, use of:                  Options.
  659. * INTERACTIVE_COMMENTS:                 Options.
  660. * INTERACTIVE_COMMENTS, use of <1>:     Miscellaneous.
  661. * INTERACTIVE_COMMENTS, use of:         Comments.
  662. * KSH_ARRAYS:                           Options.
  663. * KSH_ARRAYS, use of:                   Array Parameters.
  664. * KSH_OPTION_PRINT:                     Options.
  665. * LIST_AMBIGUOUS:                       Options.
  666. * LIST_TYPES:                           Options.
  667. * LOCAL_OPTIONS:                        Options.
  668. * LOGIN:                                Options.
  669. * LONG_LIST_JOBS:                       Options.
  670. * MAGIC_EQUAL_SUBST:                    Options.
  671. * MAIL_WARNING:                         Options.
  672. * MARK_DIRS:                            Options.
  673. * MARK_DIRS, setting in pattern:        Filename Generation.
  674. * MENU_COMPLETE:                        Options.
  675. * MENU_COMPLETE, use of:                Completion.
  676. * MONITOR:                              Options.
  677. * MONITOR, use of:                      Jobs & Signals.
  678. * NO_BAD_PATTERN:                       Options.
  679. * NO_BANG_HIST:                         Options.
  680. * NO_BEEP:                              Options.
  681. * NO_CLOBBER:                           Options.
  682. * NO_CLOBBER, use of:                   Redirection.
  683. * NO_EQUALS:                            Options.
  684. * NO_EXEC:                              Options.
  685. * NO_FLOW_CONTROL:                      Options.
  686. * NO_GLOB:                              Options.
  687. * NO_GLOB, use of:                      Filename Generation.
  688. * NO_HIST_BEEP:                         Options.
  689. * NO_HUP:                               Options.
  690. * NO_LIST_BEEP:                         Options.
  691. * NO_MULTIOS:                           Options.
  692. * NO_NOMATCH:                           Options.
  693. * NO_NOMATCH, use of:                   Filename Generation.
  694. * NO_PROMPT_CR:                         Options.
  695. * NO_RCS:                               Options.
  696. * NO_RCS, use of:                       Invocation.
  697. * NO_SHORT_LOOPS:                       Options.
  698. * NO_UNSET:                             Options.
  699. * NOTIFY:                               Options.
  700. * NULL_GLOB:                            Options.
  701. * NULL_GLOB, setting in pattern:        Filename Generation.
  702. * NULL_GLOB, use of:                    Filename Generation.
  703. * NUMERIC_GLOBSORT:                     Options.
  704. * OVER_STRIKE:                          Options.
  705. * PATH_DIRS:                            Options.
  706. * PRINT_EXIT_VALUE:                     Options.
  707. * PRIVILEGED:                           Options.
  708. * PROMPT_SUBST:                         Options.
  709. * PUSHD_IGNORE_DUPS:                    Options.
  710. * PUSHD_MINUS:                          Options.
  711. * PUSHD_MINUS, use of <1>:              Shell Builtin Commands.
  712. * PUSHD_MINUS, use of:                  Filename Expansion.
  713. * PUSHD_SILENT:                         Options.
  714. * PUSHD_SILENT, use of:                 Shell Builtin Commands.
  715. * PUSHD_TO_HOME:                        Options.
  716. * PUSHD_TO_HOME, use of:                Shell Builtin Commands.
  717. * RC_EXPAND_PARAM:                      Options.
  718. * RC_EXPAND_PARAM, use of:              Parameter Expansion.
  719. * RC_QUOTES:                            Options.
  720. * REC_EXACT:                            Options.
  721. * RM_STAR_SILENT:                       Options.
  722. * SH_GLOB:                              Options.
  723. * SH_WORD_SPLIT:                        Options.
  724. * SH_WORD_SPLIT, use of:                Parameter Expansion.
  725. * SHIN_STDIN:                           Options.
  726. * SINGLE_COMMAND:                       Options.
  727. * SINGLE_LINE_ZLE:                      Options.
  728. * SINGLE_LINE_ZLE, use of:              Zsh Line Editor.
  729. * SUN_KEYBOARD_HACK:                    Options.
  730. * VERBOSE:                              Options.
  731. * XTRACE:                               Options.
  732. * ZLE:                                  Options.
  733. * ZLE, use of:                          Zsh Line Editor.
  734. File: zsh.info,  Node: Functions Index,  Next: Editor Functions Index,  Prev: Options Index,  Up: Top
  735. Functions Index
  736. ***************
  737. * Menu:
  738. * -:                                    Shell Builtin Commands.
  739. * .:                                    Shell Builtin Commands.
  740. * alias:                                Shell Builtin Commands.
  741. * alias, use of:                        Aliasing.
  742. * autoload:                             Shell Builtin Commands.
  743. * bg:                                   Shell Builtin Commands.
  744. * bg, use of:                           Jobs & Signals.
  745. * bindkey:                              Shell Builtin Commands.
  746. * bindkey, use of:                      Zsh Line Editor.
  747. * break:                                Shell Builtin Commands.
  748. * builtin:                              Shell Builtin Commands.
  749. * bye:                                  Shell Builtin Commands.
  750. * case:                                 Complex Commands.
  751. * cd:                                   Shell Builtin Commands.
  752. * chdir:                                Shell Builtin Commands.
  753. * chpwd:                                Functions.
  754. * command:                              Shell Builtin Commands.
  755. * compctl:                              Programmable Completion.
  756. * continue:                             Shell Builtin Commands.
  757. * coproc:                               Simple Commands & Pipelines.
  758. * declare:                              Shell Builtin Commands.
  759. * dirs:                                 Shell Builtin Commands.
  760. * disable:                              Shell Builtin Commands.
  761. * disable, use of:                      Reserved Words.
  762. * disown:                               Shell Builtin Commands.
  763. * disown, use of:                       Jobs & Signals.
  764. * echo:                                 Shell Builtin Commands.
  765. * echotc:                               Shell Builtin Commands.
  766. * emulate:                              Shell Builtin Commands.
  767. * enable:                               Shell Builtin Commands.
  768. * eval:                                 Shell Builtin Commands.
  769. * exec:                                 Shell Builtin Commands.
  770. * exit:                                 Shell Builtin Commands.
  771. * export:                               Shell Builtin Commands.
  772. * false:                                Shell Builtin Commands.
  773. * fc:                                   Shell Builtin Commands.
  774. * fc, use of:                           Modifiers.
  775. * fg:                                   Shell Builtin Commands.
  776. * fg, use of:                           Jobs & Signals.
  777. * for:                                  Complex Commands.
  778. * foreach:                              Complex Commands.
  779. * function:                             Functions.
  780. * functions:                            Shell Builtin Commands.
  781. * functions, use of:                    Functions.
  782. * getln:                                Shell Builtin Commands.
  783. * getopts:                              Shell Builtin Commands.
  784. * hash:                                 Shell Builtin Commands.
  785. * history:                              Shell Builtin Commands.
  786. * if:                                   Complex Commands.
  787. * integer:                              Shell Builtin Commands.
  788. * integer, use of:                      Arithmetic Evaluation.
  789. * job:                                  Shell Builtin Commands.
  790. * jobs:                                 Shell Builtin Commands.
  791. * jobs, use of:                         Jobs & Signals.
  792. * kill:                                 Shell Builtin Commands.
  793. * let:                                  Shell Builtin Commands.
  794. * let, use of:                          Arithmetic Evaluation.
  795. * limit:                                Shell Builtin Commands.
  796. * local:                                Shell Builtin Commands.
  797. * log:                                  Shell Builtin Commands.
  798. * logout:                               Shell Builtin Commands.
  799. * noglob:                               Shell Builtin Commands.
  800. * notify, use of:                       Jobs & Signals.
  801. * periodic:                             Functions.
  802. * popd:                                 Shell Builtin Commands.
  803. * precmd:                               Functions.
  804. * print:                                Shell Builtin Commands.
  805. * pushd:                                Shell Builtin Commands.
  806. * pushln:                               Shell Builtin Commands.
  807. * pwd:                                  Shell Builtin Commands.
  808. * r:                                    Shell Builtin Commands.
  809. * read:                                 Shell Builtin Commands.
  810. * readonly:                             Shell Builtin Commands.
  811. * rehash:                               Shell Builtin Commands.
  812. * repeat:                               Complex Commands.
  813. * return:                               Shell Builtin Commands.
  814. * return, use of:                       Functions.
  815. * sched:                                Shell Builtin Commands.
  816. * select:                               Complex Commands.
  817. * set:                                  Shell Builtin Commands.
  818. * set, use of:                          Parameters.
  819. * setopt:                               Shell Builtin Commands.
  820. * shift:                                Shell Builtin Commands.
  821. * source:                               Shell Builtin Commands.
  822. * suspend:                              Shell Builtin Commands.
  823. * test:                                 Shell Builtin Commands.
  824. * times:                                Shell Builtin Commands.
  825. * trap:                                 Shell Builtin Commands.
  826. * TRAPDEBUG:                            Functions.
  827. * TRAPEXIT:                             Functions.
  828. * TRAPZERR:                             Functions.
  829. * true:                                 Shell Builtin Commands.
  830. * ttyctl:                               Shell Builtin Commands.
  831. * type:                                 Shell Builtin Commands.
  832. * typeset:                              Shell Builtin Commands.
  833. * typeset, use of:                      Parameters.
  834. * ulimit:                               Shell Builtin Commands.
  835. * umask:                                Shell Builtin Commands.
  836. * unalias:                              Shell Builtin Commands.
  837. * unfunction:                           Shell Builtin Commands.
  838. * unfunction, use of:                   Functions.
  839. * unhash:                               Shell Builtin Commands.
  840. * unlimit:                              Shell Builtin Commands.
  841. * unset:                                Shell Builtin Commands.
  842. * unsetopt:                             Shell Builtin Commands.
  843. * until:                                Complex Commands.
  844. * vared:                                Shell Builtin Commands.
  845. * wait:                                 Shell Builtin Commands.
  846. * whence:                               Shell Builtin Commands.
  847. * where:                                Shell Builtin Commands.
  848. * which:                                Shell Builtin Commands.
  849. * while:                                Complex Commands.
  850.